home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume3 / rcsit < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  22.4 KB
  1. From: talcott!topaz!packard!ihnp4!ucbvax!usc-eclc.arpa!sdcsvax!oberon!mcooper
  2. Subject: rcsit - A program to prepare files for RCS
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 61
  7. Submitted by: seismo!riacs!hplabs!sdcrdcf!uscvax!oberon!mcooper
  8.  
  9.  
  10. Appended you'll find a shar archive of a program I wrote called
  11. rcsit(1l).  I posted this program over a year ago to net.sources.
  12. After changing sites, though, I lost a copy of it and had to
  13. totally re-write it.  The new program is designed much better
  14. than the old one and seems to be much more flexible having more
  15. options.  
  16.  
  17. The program itself, does things like add rcs headers (for log
  18. tracking, version tracking, etc.) and (optionally) run rcs
  19. commands (like ci(1)) on the specified files.
  20.  
  21. Please mail me any bugs/comments that you run across.
  22.  
  23.  
  24.             Thanks,
  25.             Mike Cooper
  26. +-----------------------------------------------------------------------------+
  27. | Michael Cooper            UUCP: ...!{uscvax, sdcrdcf, engvax,          |
  28. | University Computing Services             scgvaxd, smeagol}!oberon!mcooper  |
  29. | University of Southern Cal.     BITNET: mcooper@uscvaxq, mcooper@jaxom      |
  30. | Los Angeles, Ca.   90089-0251     ARPA: mcooper@usc-oberon.arpa,          |
  31. | (213) 743-3462                mcooper@usc-eclc.arpa            |
  32. +-----------------------------------------------------------------------------+
  33. #!/bin/sh
  34. # This is a shell archive, meaning:
  35. # 1. Remove everything above the #!/bin/sh line.
  36. # 2. Save the resulting text in a file.
  37. # 3. Execute the file with /bin/sh (not csh) to create the files:
  38. #    rcsit.1
  39. #    Makefile
  40. #    rcsit.c
  41. #    _.template.c
  42. # This archive created: Tue Dec 10 13:54:54 1985
  43. # By:    Michael Cooper (University Computing Services, U.S.C.)
  44. export PATH; PATH=/bin:$PATH
  45. if test -f 'rcsit.1'
  46. then
  47.     echo shar: over-writing existing file "'rcsit.1'"
  48. fi
  49. cat << \SHAR_EOF > 'rcsit.1'
  50. ...
  51. ... $Header: rcsit.1,v 1.7 85/11/26 16:57:21 mcooper Exp $
  52. ... 
  53. ... $Log:    rcsit.1,v $
  54. ... Revision 1.7  85/11/26  16:57:21  mcooper
  55. ... Noted changes to the -t option.
  56. ... 
  57. ... Revision 1.6  85/11/11  21:20:17  mcooper
  58. ... Added AUTHOR.
  59. ... 
  60. ... Revision 1.5  85/11/11  20:13:39  mcooper
  61. ... Added description of new Fortran recognition.
  62. ... 
  63. ... Revision 1.4  85/10/27  19:18:15  mcooper
  64. ... Cleaned up table display.
  65. ... 
  66. ... Revision 1.3  85/10/27  14:55:22  mcooper
  67. ... Added description of new template feature.
  68. ... 
  69. ... Revision 1.2  85/09/28  14:22:52  mcooper
  70. ... Documented new features of checkdir (symbolic
  71. ... linking and RCSDIR).
  72. ... 
  73. ... Revision 1.1  85/09/19  15:44:22  mcooper
  74. ... Initial revision
  75. ... 
  76. ...
  77. .TH RCSIT 1l
  78. .SH NAME
  79. rcsit \- A program to prepare files for RCS
  80. .SH SYNOPSIS
  81. rcsit
  82. [
  83. .B \-chfsmM
  84. ] [
  85. .B \-qad
  86. ] [
  87. \-I\fIflags\fR
  88. ] [
  89. \-R\fIflags\fR
  90. ] [
  91. \-t\fIdirectory\fR
  92. ]
  93. .B file
  94. [
  95. .B file1, file2, ...
  96. ]
  97. .SH DESCRIPTION
  98. .I Rcsit
  99. is a semi-intelligent program to prepare files for 
  100. .I rcs(1).
  101. This
  102. involves putting the correct type of headings at the top of the file so
  103. that 
  104. .I rcs(1)
  105. will update a header and log changes in the file.
  106. .PP 
  107. By default, 
  108. .I rcsit
  109. will use default headers ``hard-wired'' into itself for each different file
  110. type that it ``knows'' about.  (See below for list of known file types).
  111. .PP
  112. If the \-t\fIdirectory\fR option is specified, then
  113. .I rcsit
  114. will use ``.template.suffix'' files
  115. (where ``suffix'' is a suffix that 
  116. .I rcsit
  117. ``knows'' about)
  118. found in 
  119. .I directory.
  120. If a directory name is not specified on the command line, then
  121. the environment variable TEMPLATES is used.
  122. If $TEMPLATES is not set, then the environment varialble, HOME is tried.
  123. .LP
  124. The following template files are recognized:
  125. .sp 2
  126. .in 10
  127. .nf
  128.  Template Name               File Type
  129.  -------------------------------------------
  130.  .template.c                 Standard C
  131.  .template.h                 C Include
  132.  .template.f                 Fortran
  133.  .template.sh                Shell Script
  134.  .template.make              Makefile
  135.  .template.man               Manual
  136. .sp 2
  137. .in -10
  138. .fi
  139. .PP
  140. .I Rcsit
  141. is ``semi-intelligent'' in that it can guess the type of headers to put in
  142. the file by the type of file (C program, C include, makefile, shell script,
  143. or manual).
  144. It determines the file type by looking at the name of the file.
  145. If the name of the file is ``Makefile'' or ``makefile'', then the
  146. file type is taken to be for 
  147. .I make(1).
  148. The suffix after the last ``.'' in the file name is then used.
  149. The following table shows the suffixes that 
  150. .I rcsit
  151. knows about:
  152. .nf
  153. .sp 2
  154. .in 10
  155. Suffix         File Type
  156. ----------------------------------------
  157. c              C Program
  158. h              C Include
  159. f              Fortran
  160. mk             \fIMake(1)\fR file
  161. sh             Shell Script
  162. csh            Shell Script
  163. [1-9]          Manual (digits 1 - 9)
  164. .fi
  165. .PP
  166. If the environement variable ``RCSDIR'' is present, then 
  167. .I rcsit
  168. will attempt to make a symbolic link from it to ``RCS'' in
  169. the current directory if the \-\fII\fR option is used and
  170. there is no directory called ``RCS'' already, in the current
  171. directory.  
  172. If the \-\fII\fR option is used and ``RCSDIR'' is not specified
  173. in the environment, then a normal directory called ``RCS'' will be
  174. created.
  175. This feature can be overrided with the \-\fId\fR option.
  176. .SH OPTIONS
  177. .TP 10
  178. .B "c"
  179. Force file type to be ``Standard C''.
  180. .TP 10
  181. .B "h"
  182. Force file type to be ``C Include''.
  183. .TP 10
  184. .B "f"
  185. Force file type to be ``Fortran''.
  186. .TP 10
  187. .B "M"
  188. Force file type to be ``Manual''.
  189. Note: If you also specify the ``I\fIflags\fR'' option,
  190. .I rcsit
  191. will run 
  192. .I rcs(1)
  193. to tell rcs what kind of comment string to use for the manual file.
  194. .TP 10
  195. .B "s"
  196. Force file type to be ``Shell Script''.
  197. .TP 10
  198. .B "m"
  199. Force file type to be ``Makefile''.  Note that this does the same thing as
  200. the -s option does.  It just prints a different message.
  201. .TP 10
  202. .B "t"
  203. Do not use any Template files for the headers.
  204. .TP 10
  205. .B "q"
  206. Be quiet.  Don't print out what is going on.  Only error messages are
  207. printed.
  208. .TP 10
  209. .B "d"
  210. Do not attempt to make the directory ``RCS''.
  211. See above for more info.
  212. .TP 10
  213. .B "a"
  214. Turn off auto guessing of file type.
  215. .TP 10
  216. .B "I\fIflags\fR"
  217. Check In file.
  218. Run RCS's 
  219. .I ci(1)
  220. on the file with ``flags'' being passed onto 
  221. .I ci(1) 
  222. as the command line arguments.
  223. .TP 10
  224. .B "R\fIflags\fR"
  225. Run 
  226. .I rcs(1)
  227. with ``flags'' as the command line arguments.
  228. .SH FILES
  229. /tmp/rcsit*    - temporary buffer
  230. .br
  231. ~/.template.*   - template files to use as the header.
  232. .br
  233. .SH AUTHOR
  234. Michael Cooper (mcooper@usc-oberon.ARPA)
  235. .SH SEE ALSO
  236. ci(1), make(1), rcs(1)
  237. .SH DIAGNOSTICS
  238. Complains about the usual stuff.  (i.e. - the specified file doesn't exist,
  239. or it can't read it...just things like that.)
  240. .SH BUGS
  241. Acts oddly in the presence of beautiful women.
  242. SHAR_EOF
  243. if test -f 'Makefile'
  244. then
  245.     echo shar: over-writing existing file "'Makefile'"
  246. fi
  247. cat << \SHAR_EOF > 'Makefile'
  248. #
  249. # $Header: Makefile,v 1.1 85/09/19 13:24:27 mcooper Exp $
  250. #
  251. # $Log:    Makefile,v $
  252. # Revision 1.1  85/09/19  13:24:27  mcooper
  253. # Initial revision
  254. # 
  255. #
  256. #
  257. # Makefile for rcsit.c
  258. #
  259. BIN = /u/mcooper/bin
  260. MAN = /u/mcooper/usr/man/manl/man1
  261.  
  262. rcsit: rcsit.c
  263.     cc -O -s -o rcsit rcsit.c
  264.  
  265. dbx: rcsit.c
  266.     cc -g rcsit.c
  267.  
  268. debug: rcsit.c
  269.     cc -g -DDEBUG rcsit.c
  270.  
  271. man: rcsit.1
  272.     nroff -man rcsit.1 > rcsit.man
  273.  
  274. install: rcsit rcsit.1
  275.     mv rcsit $(BIN)
  276.     cp rcsit.1 $(MAN)
  277. SHAR_EOF
  278. if test -f 'rcsit.c'
  279. then
  280.     echo shar: over-writing existing file "'rcsit.c'"
  281. fi
  282. cat << \SHAR_EOF > 'rcsit.c'
  283. /*
  284.  * $Header: rcsit.c,v 1.18 85/11/26 17:03:32 mcooper Exp $
  285.  *---------------------------------------------------------
  286.  * $Source: /u/mcooper/src/rcsit/RCS/rcsit.c,v $
  287.  * $Revision: 1.18 $
  288.  * $Date: 85/11/26 17:03:32 $
  289.  * $State: Exp $
  290.  * $Author: mcooper $
  291.  * $Locker: mcooper $
  292.  *---------------------------------------------------------
  293.  * Michael Cooper (mcooper@usc-oberon.arpa)
  294.  * University of Southern California,
  295.  * University Computing Services,
  296.  * Los Angeles, California,   90089-0251
  297.  * (213) 743-3469
  298.  *---------------------------------------------------------
  299.  *
  300.  * $Log:    rcsit.c,v $
  301.  * Revision 1.18  85/11/26  17:03:32  mcooper
  302.  * Change message telling of what header was added.
  303.  * 
  304.  * Revision 1.17  85/11/26  16:40:55  mcooper
  305.  * Changed the default -t option to FALSE.
  306.  * Added specifying directory to look for .template.*
  307.  * files in via -tdirectory.
  308.  * 
  309.  * Revision 1.16  85/11/11  21:35:34  mcooper
  310.  * Added call to access() to see if the file
  311.  * could be read.
  312.  * 
  313.  * Revision 1.15  85/11/11  21:22:33  mcooper
  314.  * Changed comment char for fortran files
  315.  * from "*" to "c".  This is what RCS uses.
  316.  * 
  317.  * Revision 1.14  85/11/11  20:08:43  mcooper
  318.  * Added descriptions for fortran (.f) files.
  319.  * 
  320.  * Revision 1.13  85/11/11  19:52:17  mcooper
  321.  * Modified default header templates to not bother specifying
  322.  * the RCS file name of the file.  co(1) worries about it.
  323.  * 
  324.  * Revision 1.12  85/10/27  19:10:07  mcooper
  325.  * Fixed bug that would not use template files if a file
  326.  * type was forced with -c, -h, etc.
  327.  * 
  328.  * Revision 1.11  85/10/27  18:48:27  mcooper
  329.  * Extended template file.  You can now have template
  330.  * files describing all the types of files that
  331.  * rcsit "knows" about.  The file $HOME/.template.*
  332.  * (where ``*'' is a ``.'' suffix rcsit can guess at or
  333.  * the type of file that is specified with an override)
  334.  * is checked for existance.  If not present, the default
  335.  * header (built into rcsit) will be used.
  336.  * 
  337.  * Revision 1.10  85/10/27  16:15:53  mcooper
  338.  * Added printing of what rcsit is doing if tflag is
  339.  * true.  Also added new headers.
  340.  * 
  341.  * Revision 1.9  85/10/27  14:47:39  mcooper
  342.  * Added new template feature.  If the file
  343.  * .template exists in the users HOME directory,
  344.  * then that file is used as the header file instead
  345.  * of the defaults for each type of file.  This can
  346.  * be disabled with the -t option in case the file
  347.  * is say a shell script.  With the template feature
  348.  * turned off, the auto guessing is re-inabled.
  349.  * Also, rcsit now removes its temporary files.
  350.  * 
  351.  * Revision 1.8  85/09/28  14:11:45  mcooper
  352.  * Added feature: if the environment variable RCSDIR is
  353.  * present, rcsit will attempt to make a symbolic
  354.  * link to the directory when the -I flag is used.
  355.  * This is done only when -I is specified AND the 
  356.  * directory RCS is not present.  You may disable this
  357.  * feature with the -d option.  Note also that if RCSDIR
  358.  * is not in the environment and the above conditions
  359.  * are true, that a normal directory called RCS will
  360.  * be created.
  361.  * 
  362.  * Revision 1.7  85/09/19  15:59:53  mcooper
  363.  * Kludge part 2 -- If you specify a ci -l of a
  364.  * man file, then the header is messed up. 
  365.  * Fix: After initializing the comment string,
  366.  * unlink the file and then run co -l.
  367.  * 
  368.  * Revision 1.6  85/09/19  15:39:57  mcooper
  369.  * Now knows about ``Manual'' type files.
  370.  * 
  371.  * Revision 1.5  85/09/19  14:23:24  mcooper
  372.  * Added lineprint() function to print things out
  373.  * nicely.  Fixed bug for Manual type files.  Due
  374.  * to the fact that RCS does not not the suffixes of
  375.  * manuals, it therefor does not know what kind of
  376.  * comment string to use.  Thus, I kludge by running
  377.  * a ``rcs -c`... ' file'' to tell rcs the comment
  378.  * string.
  379.  * 
  380.  * Revision 1.4  85/09/19  13:28:22  mcooper
  381.  * Fixed bug in auto_guess.  Would not continue through function
  382.  * when file type was ``Makefile''.
  383.  * 
  384.  * Revision 1.3  85/09/19  13:19:50  mcooper
  385.  * Added ``Shell Script'' file type.
  386.  * 
  387.  * Revision 1.2  85/09/19  10:08:36  mcooper
  388.  * Added code to run RCS commands (rcs & ci) on files.
  389.  * Fixed bug that limited number of command line files specified to
  390.  * nine.  Several other minor fixes and improvements.
  391.  * 
  392.  * Revision 1.1  85/09/17  11:33:33  mcooper
  393.  * Initial revision
  394.  * 
  395.  */
  396.  
  397. /*
  398.  * rcsit --     Prepare files for RCS.  rcsit puts the correct headings
  399.  *        at the top of files to prepare them for RCS headings
  400.  *        and log tracking.
  401.  *
  402.  * Michael Cooper    (mcooper@usc-oberon.arpa)
  403.  * University Computing Services, USC
  404.  *
  405.  * 9-16-85
  406.  */
  407.  
  408. #include <stdio.h>
  409. #include <ctype.h>
  410. #include <sys/file.h>
  411.  
  412. #ifdef NULL
  413. #undef NULL
  414. #endif
  415. #define NULL        '\0'
  416. #define LENGTH        132        /* length of line */
  417. #define TRUE        1
  418. #define FALSE        0
  419.  
  420. #ifdef DEBUG
  421.  int debugon = TRUE;
  422. #else
  423.  int debugon = FALSE;
  424. #endif
  425.  
  426. static char     *progname;        /* program name */
  427. static char     *rcsdir;
  428.  
  429. /*
  430.  * Messages to be printed for the user.
  431.  */
  432. static char    *msg_name;        
  433. static char     *m_stdc = "Standard C",
  434.         *m_include = "C Include",
  435.         *m_fortran = "Fortran",
  436.         *m_pascal = "Pascal",
  437.         *m_make    = "Makefile",
  438.         *m_shell = "Shell Script",
  439.         *m_manual = "Manual";
  440.  
  441. /*
  442.  * The headers to put at the beginning of the file(s).
  443.  * Notice that the words Header and Log do not appear here
  444.  * because RCS will put in the keyword substitutions when rcsit.c
  445.  * is co'ed.
  446.  */
  447. static char    *header;
  448. static char    *h_stdc = 
  449.     "static char *RCSid = \"$%s$\";\n\n/*\n * $%s$\n */\n\n";
  450. static char    *h_include = 
  451.     "/*\n * $%s$\n *\n * $%s$\n */\n\n";
  452. static char    *h_make =
  453.     "#\n# $%s$\n#\n# $%s$\n#\n";
  454. static char     *h_manual =
  455.     "...\n... $%s$\n... \n... $%s$\n...\n";
  456. static char     *h_fortran =
  457.     "c\nc $%s$\nc\nc $%s$\nc\n";
  458.  
  459. /*
  460.  * Template file names
  461.  */
  462. static char    *template_c     = ".template.c";    /* .c template */
  463. static char     *template_h     = ".template.h";    /* .h template */
  464. static char     *template_f     = ".template.f";    /* .f template */
  465. static char     *template_p     = ".template.p";    /* .p template */
  466. static char     *template_man     = ".template.man";    /* man template */
  467. static char    *template_make    = ".template.make";    /* make template */
  468. static char    *template_sh    = ".template.sh";    /* sh script template */
  469. static char    *tpath;                    /* path to template */
  470. static char    tfile[BUFSIZ];                /* template file */
  471. static char    tbuf[BUFSIZ];                /* current tfile */
  472.  
  473. /*
  474.  * Command line flags
  475.  */
  476. int    Iflag    = FALSE;            /* run ci(1) */
  477. int    rcsflag = FALSE;            /* run rcs(1) */
  478. int    aflag    = TRUE;                /* do auto guess */
  479. int    dflag    = TRUE;                /* creat RCS dir. */
  480. int    qflag    = FALSE;            /* be quiet! */
  481. int     cflag    = FALSE;            /* std c file */
  482. int    fflag    = FALSE;            /* fortran file */
  483. int    pflag    = FALSE;            /* pascal file */
  484. int    hflag    = FALSE;            /* include file */
  485. int    sflag    = FALSE;            /* shell script */
  486. int     mflag    = FALSE;            /* Makefile */
  487. int    Mflag    = FALSE;            /* manual */
  488. int    tflag    = FALSE;            /* template flag */
  489.  
  490. main(argc, argv)
  491. int    argc;
  492. char     *argv[];
  493. {
  494.     int x;
  495.     char    tmp[LENGTH];
  496.     char    *file;
  497.     char    *flags;
  498.     char     *tmpfile = "/tmp/rcsitXXXXXX";
  499.     char     *mktemp();
  500.     char    *gettmp();
  501.     char    *getenv();
  502.     FILE     *fd, 
  503.         *fdtmp,
  504.         *fopen();
  505.  
  506.     progname = *argv;
  507.     for (x = 1; x < argc; x++) {
  508.         if (argv[x][0] != '-')
  509.             break;
  510.         switch (argv[x][1]) {
  511.             case 'a':
  512.                 aflag = FALSE;
  513.                 break;
  514.             case 'q':
  515.                 qflag = TRUE;
  516.                 break;
  517.             case 'd':
  518.                 dflag = FALSE;
  519.                 break;
  520.             case 'f':
  521.                 fflag = TRUE;
  522.                 break;
  523.             case 'h':
  524.                 hflag = TRUE;
  525.                 break;
  526.             case 's':
  527.                 sflag = TRUE;    
  528.                 break;
  529.             case 'm':
  530.                 mflag = TRUE;
  531.                 break;
  532.             case 'M':
  533.                 Mflag = TRUE;
  534.                 break;
  535.             case 'i':
  536.             case 'I':
  537.                 Iflag = TRUE;
  538.                 flags = &argv[x][2];
  539.                 break;
  540.             case 'r':
  541.             case 'R':
  542.                 rcsflag = TRUE;
  543.                 flags = &argv[x][2];
  544.                 break;
  545.             case 't':
  546.                 tflag = TRUE;
  547.                 tpath = &argv[x][2];
  548.                 break;
  549.             case 'c':
  550.                 cflag = TRUE;
  551.                 break;
  552.             default:
  553.                 fatal("Unknown flag %s.",argv);
  554.         }
  555.     }
  556.     argc -= (x - 1);
  557.     argv += (x - 1);
  558.  
  559.     if((hflag && (mflag || Mflag || cflag)) ||
  560.         (mflag && (hflag || cflag || Mflag)) ||
  561.         (Mflag && (cflag || hflag || mflag)) ||
  562.         (cflag && (hflag || Mflag || mflag))) {
  563.             fatal("Only ONE of -c,-f,-m,-M,-h,-s may be specified.");
  564.     }
  565.     if(Iflag && rcsflag) {
  566.             fatal("Only ONE of ``-i'' and ``-r'' may be specified.");
  567.     }
  568.  
  569.     if(cflag || hflag || mflag || Mflag || fflag || sflag)
  570.         aflag = FALSE;
  571.  
  572.     if((rcsdir = getenv("RCSDIR")) == NULL)
  573.         rcsdir = "RCS";
  574.     if(Iflag && dflag)
  575.         checkdir();    /* Make RCS directory for ci */
  576.  
  577.     if((*tpath == NULL) && ((tpath = getenv("TEMPLATE")) == NULL))
  578.         if((tpath = getenv("HOME")) == NULL)
  579.             fatal("Cannot find environment variable HOME or TEMPLATE");
  580.  
  581.     /*
  582.      * make tmp file once.
  583.      */
  584.     mktemp(tmpfile);
  585.  
  586.     while (--argc) {    /* Main loop */
  587.         file = *++argv;
  588.         debug(sprintf(tmp, "...file (*++argv) = %s...", file));
  589.  
  590.         if(access(file, 4) != 0)
  591.             fatal("Cannot access %s.  No read permission OR file does not exist.",
  592.                 file);
  593.         if((fdtmp = fopen(tmpfile, "w")) == NULL) {
  594.             fatal("Cannot open tmpfile (%s).", tmpfile);
  595.         }
  596.  
  597.         if(aflag)
  598.             auto_guess(file); /* try and guess file type */
  599.         else
  600.             set_flags();      /* check and set flags */
  601.  
  602.         if(tflag) {
  603.             /*
  604.              * first get names of templates, then create
  605.              * path name to it.
  606.              */
  607.             get_temp();
  608.             sprintf(tfile, "%s/%s", tpath, tbuf);
  609.         }
  610.         if(access(tfile, 0) == 0 && tflag) {
  611.             if(!qflag || debugon)
  612.                 printf("Adding %s header file to %s...",
  613.                     msg_name, file);
  614.             copy(tfile, tmpfile, "w");
  615.             copy(file, tmpfile, "a");
  616.         } else {
  617.             if(!qflag || debugon)
  618.                 printf(
  619.                 "Adding default header (%s format) to %s...",
  620.                     msg_name, file);
  621.             /*
  622.              * put the Keywords into header string
  623.              */
  624.             sprintf(tmp, header, "Header", "Log");
  625.             fputs(tmp, fdtmp);
  626.             /*
  627.              * fclose'em, just in case.
  628.              */
  629.             fclose(fdtmp);
  630.             copy(file, tmpfile, "a");
  631.         }
  632.         unlink(file);
  633.         copy(tmpfile, file, "w");
  634.         unlink(tmpfile);
  635.  
  636.         if(!qflag || debugon)
  637.             printf("done.\n");
  638.  
  639.         if(Iflag){
  640.             rcs("ci", file, flags);
  641.             if(Mflag){    /* kludge to tell rcs about manuals */
  642.                 rcs("rcs", file, "c'... '");
  643.                 /*
  644.                  * kludge part 2 - if the user tried a ci
  645.                  * with a -l option, then the header is
  646.                  * messed up in the currently checked out
  647.                  * man file.  So we have to co the file to 
  648.                  * clean up the header.  Plus we use the
  649.                  * -l option of co to insure file locking.
  650.                  */
  651.                 if(checkfor("l", flags)){
  652.                     unlink(file);
  653.                     rcs("co", file, "l");
  654.                 }
  655.             }
  656.         }
  657.         if(rcsflag)
  658.             rcs("rcs", file, flags);
  659.     }
  660. }
  661.  
  662. /*
  663.  * debug - print (useless) debugging info.
  664.  */
  665.  
  666. debug(msg)
  667. char *msg;
  668. {
  669. #ifdef DEBUG
  670.     fprintf(stderr, msg);
  671.     putchar ('\n');
  672. #endif
  673. }
  674.  
  675. /*
  676.  * auto_guess - try and be intelligent and guess type of file
  677.  *        by looking at the suffix or the whole name
  678.  *        in the case of a makefile.
  679.  */
  680.  
  681. auto_guess(file)
  682. char    *file;
  683. {
  684.     char *suffix;
  685.     char *rindex();
  686.  
  687.     suffix = rindex(file, '.')+1;
  688.     if((strcmp(file, "makefile") == 0) || (strcmp(file, "Makefile") == 0) ||
  689.         (strcmp(suffix, "mk") == 0)) {    /* sys V std suffix */
  690.         mflag = TRUE;
  691.         sflag = FALSE;
  692.         cflag = FALSE;
  693.         hflag = FALSE;
  694.         Mflag = FALSE;
  695.         fflag = FALSE;
  696.     }
  697.     if((strcmp(suffix, "sh") == 0) || (strcmp(suffix, "csh") == 0)) {
  698.         sflag = TRUE;
  699.         cflag = FALSE;
  700.         hflag = FALSE;
  701.         mflag = FALSE;
  702.         Mflag = FALSE;
  703.         fflag = FALSE;
  704.     }
  705.     if(strcmp(suffix, "c") == 0){
  706.         cflag = TRUE;
  707.         hflag = FALSE;
  708.         mflag = FALSE;
  709.         Mflag = FALSE;
  710.         sflag = FALSE;
  711.         fflag = FALSE;
  712.     }
  713.     if(strcmp(suffix, "h") == 0){
  714.         hflag = TRUE;
  715.         cflag = FALSE;
  716.         mflag = FALSE;
  717.         Mflag = FALSE;
  718.         sflag = FALSE;
  719.         fflag = FALSE;
  720.     }
  721.     if(strcmp(suffix, "f") == 0){
  722.         fflag = TRUE;
  723.         hflag = FALSE;
  724.         cflag = FALSE;
  725.         mflag = FALSE;
  726.         Mflag = FALSE;
  727.         sflag = FALSE;
  728.     }
  729.     if(isdigit(*suffix) != 0) {
  730.         Mflag = TRUE;
  731.         hflag = FALSE;
  732.         cflag = FALSE;
  733.         mflag = FALSE;
  734.         sflag = FALSE;
  735.         fflag = FALSE;
  736.     }
  737.     set_flags();
  738.     if(!qflag || debugon)
  739.         printf("Hmm.  This file looks like a %s file.\n", msg_name);
  740. }
  741.  
  742. /*
  743.  * set_flags - set & check flags
  744.  */
  745.  
  746. set_flags()
  747. {
  748.     if(cflag || hflag || mflag || Mflag || sflag || fflag) {
  749.         if(cflag) {
  750.             msg_name = m_stdc;
  751.             header = h_stdc;
  752.         }
  753.         if(hflag) {
  754.             msg_name = m_include;
  755.             header = h_include;
  756.         }
  757.         if(mflag) {
  758.             msg_name = m_make;
  759.             header = h_make;
  760.         }
  761.         if(Mflag) {
  762.             msg_name = m_manual;
  763.             header = h_manual;
  764.         }
  765.         if(sflag) {
  766.             msg_name = m_shell;
  767.             header = h_make;
  768.         }
  769.         if(fflag) {
  770.             msg_name = m_fortran;
  771.             header = h_fortran;
  772.         }
  773.     } else {
  774.         cflag = TRUE;
  775.         set_flags();
  776.     }
  777. }
  778.  
  779. /*
  780.  * copy from -> to
  781.  */
  782.  
  783. copy(from, to, mode)
  784. char *from;
  785. char *to;
  786. char *mode;
  787. {
  788.     FILE *fdfrom, *fdto, *fopen();
  789.     char tmp[LENGTH];
  790.     char s[LENGTH];
  791.  
  792.     if((fdfrom = fopen(from, "r")) == NULL) {
  793.         fatal("Cannot open %s for reading.",from);
  794.     }
  795.     if((fdto = fopen(to, mode)) == NULL) {
  796.         fatal("Cannot open %s for \"%s\".",to,mode);
  797.     }
  798.     while(fgets(s, sizeof(s), fdfrom) != NULL)
  799.         fputs(s, fdto);
  800.     fclose(fdfrom);
  801.     fclose(fdto);
  802. }
  803.  
  804. /*
  805.  * Run RCS's rcsprog on file with flags.
  806.  */
  807.  
  808. rcs(rcsprog, file, flags)
  809. char *rcsprog;
  810. char *file;
  811. char *flags;
  812. {
  813.     char buf[LENGTH];
  814.     char tmp[LENGTH];
  815.  
  816.     if(!checkfor("q", flags) && qflag)
  817.         flags = "q";
  818.     if(strcmp(flags, NULL) == 0)
  819.         sprintf(buf, "%s %s", rcsprog, file);
  820.     else
  821.         sprintf(buf, "%s -%s %s", rcsprog, flags, file);
  822.     debug(sprintf(tmp,"Running ``%s''...\n", buf));
  823.     if(!qflag)
  824.         lineprint(sprintf(tmp, "Start of ``%s''", buf));
  825.     system(buf);
  826.     if(!qflag)
  827.         lineprint(sprintf(tmp, "End of ``%s''", buf));
  828. }
  829.  
  830. /*
  831.  * checkdir - make RCS directory if not present.
  832.  */
  833.  
  834. checkdir()
  835. {
  836.     if(access("RCS", 0) != 0){
  837.         if(!qflag || debugon)
  838.             printf("Cannot find \"RCS\" directory.  Creating...\n");
  839.         if(strcmp(rcsdir, "RCS") != 0) { 
  840.             if(symlink(rcsdir, "RCS") != 0)
  841.                 fatal("Symbolic link of %s to RCS failed.", 
  842.                     rcsdir);
  843.         } else {
  844.             if(mkdir(rcsdir, 0755) != 0)
  845.                 fatal("Cannot create \"%s\" directory.", 
  846.                     rcsdir);
  847.         }
  848.     }
  849. }
  850.  
  851. /*
  852.  * checkfor(x, str) -- check for x in str.  Return 1 (TRUE) if exists.
  853.  *            Otherwise 0 (FALSE).
  854.  */
  855.  
  856. checkfor(x, str)
  857. char     *x;
  858. char     *str;
  859. {
  860.     while(*str) {
  861.         if(strcmp(str, x) == 0)
  862.             return(TRUE);
  863.         *str++;
  864.     }
  865.     return(FALSE);
  866. }
  867.  
  868. /*
  869.  * lineprint - print msg in a nice line
  870.  */
  871.  
  872. lineprint(msg)
  873. char *msg;
  874. {
  875.     int len, left, right, x;
  876.  
  877.     len = strlen(msg);
  878.     right = (75-len)/2;
  879.     left = right;
  880.     for(x = 0; x < right; ++x)
  881.         putchar('-');
  882.     printf("[ %s ]", msg);
  883.     for(x = 0; x < left; ++x)
  884.         putchar('-');
  885.     putchar('\n');
  886. }
  887.  
  888. /*
  889.  * fatal - print error and then exit(1).
  890.  */
  891. fatal(format, str)
  892. char *format;
  893. {
  894.     static char namefmt[100];
  895.  
  896.     sprintf(namefmt, "%s: %s\n", progname, format);
  897.     _doprnt(namefmt, &str, stderr);
  898.     exit(1);
  899. }
  900.  
  901. /*
  902.  * zap str with NULL's
  903.  */
  904.  
  905. zap(str)
  906. char str[];
  907. {
  908.     int i, x;
  909.  
  910.     i = strlen(str);
  911.     for(x = 0; x <= i; )
  912.         str[x++] = NULL;
  913. }
  914.  
  915. /*
  916.  * get template names
  917.  */
  918.  
  919. get_temp()
  920. {
  921.     zap(tbuf);
  922.     if(mflag)
  923.         strcpy(tbuf, template_make);
  924.     if(Mflag)
  925.         strcpy(tbuf, template_man);
  926.     if(hflag)
  927.         strcpy(tbuf, template_h);
  928.     if(cflag)
  929.         strcpy(tbuf, template_c);
  930.     if(sflag)
  931.         strcpy(tbuf, template_sh);
  932.     if(fflag)
  933.         strcpy(tbuf, template_f);
  934. }
  935. SHAR_EOF
  936. if test -f '_.template.c'
  937. then
  938.     echo shar: over-writing existing file "'_.template.c'"
  939. fi
  940. cat << \SHAR_EOF > '_.template.c'
  941. /*
  942.  * $Header$
  943.  *------------------------------------------------------------------
  944.  *
  945.  * $Source$
  946.  * $Revision$
  947.  * $Date$
  948.  * $State$
  949.  * $Author$
  950.  * $Locker$
  951.  *
  952.  *------------------------------------------------------------------
  953.  *
  954.  * Michael Cooper (mcooper@usc-oberon.arpa)
  955.  * University Computing Services,
  956.  * University of Southern California,
  957.  * Los Angeles, California,   90089-0251
  958.  * (213) 743-3469
  959.  *
  960.  *------------------------------------------------------------------
  961.  * $Log$
  962.  *------------------------------------------------------------------
  963.  */
  964.  
  965. SHAR_EOF
  966. #    End of shell archive
  967. exit 0
  968.  
  969.